home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 07 - 1991 / 07.11 Nov 91 / Jorg Sources / MacTutor7App.cp next >
Encoding:
Text File  |  1991-09-23  |  8.6 KB  |  379 lines  |  [TEXT/MPS ]
  1. /*------------------------------------------------------------------------------
  2. #    MacTutorApp
  3. #
  4. #    A rudimentary application skeleton
  5. #    J. Langowski / MacTutor 1989
  6. #    Added high-level event support / JL Sept. 1991
  7. #------------------------------------------------------------------------------*/
  8. #include <Types.h>
  9. #include <QuickDraw.h>
  10. #include <Fonts.h>
  11. #include <Events.h>
  12. #include <OSEvents.h>
  13. #include <Controls.h>
  14. #include <Windows.h>
  15. #include <Menus.h>
  16. #include <TextEdit.h>
  17. #include <Dialogs.h>
  18. #include <Desk.h>
  19. #include <Scrap.h>
  20. #include <ToolUtils.h>
  21. #include <Memory.h>
  22. #include <SegLoad.h>
  23. #include <Files.h>
  24. #include <OSUtils.h>
  25. #include <Traps.h>
  26. #include <StdLib.h>
  27.  
  28. #include <AppleEvents.h> 
  29. #include <GestaltEqu.h> 
  30.  
  31. #include "TDocument.h"
  32. #include "TApplication.h"
  33. #include "MacTutor7App.h"
  34. #include "MacTutorDoc.h"
  35. #include "MacTutorGrow.h"
  36.  
  37. const short kOSEvent = app4Evt;
  38.  
  39. // Our application object, initialized in main(). We make it
  40. // global so our functions which don't belong to any class
  41. // can find the active document.
  42. TMacTutorApp *gTheApplication;
  43.  
  44. /*     Handlers for the requires AppleEvent suite */
  45.  
  46. // Create a new document and window. 
  47. void TMacTutorApp::DoNew(void)
  48. {
  49.     TMacTutorGrow* tMacTutorDoc;
  50.     
  51.     tMacTutorDoc = new TMacTutorGrow(rDocWindow,"\pNothing selected yet.");
  52.     // if we didn't get an allocation error, add it to list
  53.     if (tMacTutorDoc != nil)
  54.       fDocList->AddDoc(tMacTutorDoc);
  55. }
  56.  
  57. // do the necessary things when you get an 'oapp' high level event
  58. void TMacTutorApp::DoOpen(void) { SysBeep(5); DoNew(); }
  59.  
  60. // We don't print any documents
  61. void TMacTutorApp::DoPrint(void) { SysBeep(5); }
  62.  
  63. void TMacTutorApp::Terminate(void) { ExitLoop(); }
  64.  
  65. void TMacTutorApp::DoHighLevelEvent(void)
  66. {
  67.     AEProcessAppleEvent(&fTheEvent);
  68. }
  69.  
  70. void AEDoOpen(void) { gTheApplication->DoOpen(); }
  71. void AEDoNew(void) { gTheApplication->DoNew(); }
  72. void AEDoPrint(void) { gTheApplication->DoPrint(); }
  73. void AETerminate(void) { gTheApplication->Terminate(); }
  74.  
  75. // initialize the application
  76. TMacTutorApp::TMacTutorApp(void)
  77. {
  78.     Handle    menuBar;
  79.  
  80.     // initialize Apple Event handlers
  81.     OSErr    err;
  82.     long    result;
  83.     Boolean gHasAppleEvents;
  84.     
  85.     
  86.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &result) ? false : result != 0);
  87.  
  88.     if (gHasAppleEvents) {
  89.             err = AEInstallEventHandler(kCoreEventClass,
  90.                     kAEOpenApplication, 
  91.                     (EventHandlerProcPtr) &AEDoOpen, 0L, false);
  92.             err = AEInstallEventHandler(kCoreEventClass,
  93.                     kAEOpenDocuments, 
  94.                     (EventHandlerProcPtr) &AEDoNew, 0L, false);
  95.             err = AEInstallEventHandler(kCoreEventClass,
  96.                     kAEPrintDocuments, 
  97.                     (EventHandlerProcPtr) &AEDoPrint, 0L, false);
  98.             err = AEInstallEventHandler(kCoreEventClass,
  99.                     kAEQuitApplication,
  100.                     (EventHandlerProcPtr) &AETerminate, 0L, false);
  101.         }
  102.     
  103.     // read menus into menu bar
  104.     menuBar = GetNewMBar(rMenuBar);
  105.     // install menus
  106.     SetMenuBar(menuBar);
  107.     DisposHandle(menuBar);
  108.     // add DA names to Apple menu
  109.     AddResMenu(GetMHandle(mApple), 'DRVR');
  110.     DrawMenuBar();
  111.  
  112.     // create empty mouse region
  113.     fMouseRgn = NewRgn();
  114. }
  115.  
  116. // Tell TApplication class how much heap we need
  117. long TMacTutorApp::HeapNeeded(void)
  118. {
  119.     return (kMinSize * 1024);
  120. }
  121.  
  122. // Calculate a sleep value for WaitNextEvent. This takes into account the things
  123. // that DoIdle does with idle time.
  124.  
  125. unsigned long TMacTutorApp::SleepVal(void)
  126. {
  127.     unsigned long sleep;
  128.     const long kSleepTime = 0x7fffffff;    // a very large positive number
  129.  
  130.     sleep = kSleepTime;                // default value for sleep
  131.     if ((!fInBackground))
  132.     {
  133.           sleep = GetCaretTime();    // A reasonable time interval for MenuClocks, etc.
  134.     }
  135.     return sleep;
  136. }
  137.  
  138. void TMacTutorApp::AdjustMenus(void)
  139. {
  140.     WindowPtr    frontmost;
  141.     MenuHandle    menu;
  142.     Boolean undo,cutCopyClear,paste;
  143.  
  144.     TMacTutorDocument* fMacTutorCurDoc = (TMacTutorDocument*) fCurDoc;
  145.  
  146.     frontmost = FrontWindow();
  147.  
  148.     menu = GetMHandle(mFile);
  149.     if ( fDocList->NumDocs() < kMaxOpenDocuments )
  150.       EnableItem(menu, iNew);            // New is enabled when we can open more documents 
  151.     else DisableItem(menu, iNew);
  152.     if ( frontmost != (WindowPtr) nil )    // Close is enabled when there is a window to close 
  153.       EnableItem(menu, iClose);
  154.     else DisableItem(menu, iClose);
  155.  
  156.     undo = false;
  157.     cutCopyClear = false;
  158.     paste = false;
  159.     
  160.     if ( fMacTutorCurDoc == nil )
  161.       {
  162.         undo = true;                // all editing is enabled for DA windows 
  163.         cutCopyClear = true;
  164.         paste = true;
  165.       }
  166.       
  167.     menu = GetMHandle(mEdit);
  168.     if ( undo )
  169.         EnableItem(menu, iUndo);
  170.     else
  171.         DisableItem(menu, iUndo);
  172.     
  173.     if ( cutCopyClear )
  174.       {
  175.         EnableItem(menu, iCut);
  176.         EnableItem(menu, iCopy);
  177.         EnableItem(menu, iClear);
  178.       } 
  179.     else
  180.       {
  181.         DisableItem(menu, iCut);
  182.         DisableItem(menu, iCopy);
  183.         DisableItem(menu, iClear);
  184.       }
  185.       
  186.     if ( paste )
  187.         EnableItem(menu, iPaste);
  188.     else
  189.         DisableItem(menu, iPaste);
  190.         
  191.     menu = GetMHandle(myMenu);
  192.         EnableItem(menu, item1);
  193.         EnableItem(menu, item2);
  194.         EnableItem(menu, item3);
  195.         EnableItem(menu, item5);
  196.  
  197.         CheckItem(menu, item1, false);
  198.         CheckItem(menu, item2, false);
  199.         CheckItem(menu, item3, false);
  200.         CheckItem(menu, item5, false);
  201.         CheckItem(menu, fMacTutorCurDoc->GetItemSelected(), true);
  202. } // AdjustMenus
  203.  
  204. void TMacTutorApp::DoMenuCommand(short menuID, short menuItem)
  205. {
  206.     short        itemHit;
  207.     Str255        daName;
  208.     short        daRefNum;
  209.     WindowPtr    window;
  210.     TMacTutorDocument* fMacTutorCurDoc = (TMacTutorDocument*) fCurDoc;
  211.  
  212.     window = FrontWindow();
  213.     switch ( menuID )
  214.       {
  215.         case mApple:
  216.             switch ( menuItem )
  217.               {
  218.                 case iAbout:        // About box
  219.                     itemHit = Alert(rAboutAlert, nil);
  220.                     break;
  221.                 default:            // DAs etc.
  222.                     GetItem(GetMHandle(mApple), menuItem, daName);
  223.                     daRefNum = OpenDeskAcc(daName);
  224.                     break;
  225.               }
  226.             break;
  227.         case mFile:
  228.             switch ( menuItem )
  229.               {
  230.                 case iNew:
  231.                     DoNew();
  232.                     break;
  233.                 case iClose:
  234.                     if (fMacTutorCurDoc != nil)
  235.                       {
  236.                         fDocList->RemoveDoc(fMacTutorCurDoc);
  237.                         delete fMacTutorCurDoc;
  238.                       }
  239.                     else CloseDeskAcc(((WindowPeek) fWhichWindow)->windowKind);
  240.                     break;
  241.                 case iQuit:
  242.                     Terminate();
  243.                     break;
  244.               }
  245.             break;
  246.         case mEdit:                    // call SystemEdit for DA editing & MultiFinder 
  247.             if ( !SystemEdit(menuItem-1) )
  248.               {
  249.                 switch ( menuItem )
  250.                   {
  251.                     case iCut:
  252.                         break;
  253.                     case iCopy:
  254.                         break;
  255.                     case iPaste:
  256.                         break;
  257.                     case iClear:
  258.                         break;
  259.                    }
  260.               }
  261.             break;
  262.         case myMenu:
  263.             if (fMacTutorCurDoc != nil) 
  264.             {
  265.                 switch ( menuItem )
  266.                   {
  267.                     case item1:
  268.                         fMacTutorCurDoc->SetDisplayString("\pC++");
  269.                         break;
  270.                     case item2:
  271.                         fMacTutorCurDoc->SetDisplayString("\pSample");
  272.                         break;
  273.                     case item3:
  274.                         fMacTutorCurDoc->SetDisplayString("\pApplication");
  275.                         break;
  276.                     case item5:
  277.                         fMacTutorCurDoc->SetDisplayString("\pHave Fun");
  278.                         break;
  279.                    }
  280.             fMacTutorCurDoc->SetItemSelected(menuItem);
  281.             InvalRect(&(window->portRect));
  282.             fMacTutorCurDoc->DoUpdate();
  283.             }
  284.             break;
  285.       }
  286.     HiliteMenu(0);
  287. } // DoMenuCommand
  288.  
  289.  
  290. void TMacTutorApp::EventLoop(void)
  291.     // overridden to accommodate high level events
  292. {
  293.     int gotEvent;
  294.     EventRecord tEvt;
  295.  
  296.     SetUp();                    // call setup routine
  297.     DoIdle();                    // do idle once
  298.  
  299.     while (fDone == false)
  300.       {
  301.         // always set up fWhichWindow before doing anything
  302.         fWhichWindow = FrontWindow();
  303.         // see if window belongs to a document
  304.         fCurDoc = fDocList->FindDoc(fWhichWindow);
  305.         // make sure we always draw into correct window
  306.         SetPort(fWhichWindow);
  307.  
  308.         DoIdle();            // call idle time handler
  309.         
  310.         if (fHaveWaitNextEvent)
  311.           {
  312.             gotEvent = WaitNextEvent(everyEvent, &tEvt, SleepVal(), fMouseRgn);
  313.           }
  314.         else
  315.           {
  316.             SystemTask();
  317.             gotEvent = GetNextEvent(everyEvent, &tEvt);
  318.           }
  319.         fTheEvent = tEvt;
  320.  
  321.         // make sure we got a real event
  322.         if ( gotEvent )
  323.           {
  324.             AdjustCursor();
  325.             switch (fTheEvent.what)
  326.               {
  327.                 case mouseDown :
  328.                     DoMouseDown();
  329.                     break;
  330.                 case mouseUp :
  331.                     DoMouseUp();
  332.                     break;
  333.                 case keyDown :
  334.                 case autoKey :
  335.                     DoKeyDown();
  336.                     break;
  337.                 case updateEvt :
  338.                     DoUpdateEvt();                
  339.                     break;
  340.                 case diskEvt :
  341.                     DoDiskEvt();
  342.                     break;
  343.                 case activateEvt :
  344.                     DoActivateEvt();
  345.                     break;
  346.                 case kHighLevelEvent :        // added Sept 91
  347.                     DoHighLevelEvent();        // J.L.
  348.                     break;                    //
  349.                 case kOSEvent :
  350.                     DoOSEvent();
  351.                     break;
  352.                 default :
  353.                     break;
  354.               } // end switch (fTheEvent.what)
  355.           }
  356.         AdjustCursor();
  357.       }
  358.     // call cleanup handler
  359.     CleanUp();
  360. }
  361.  
  362.  
  363. // main is the entrypoint to the program
  364. int main(void)
  365. {
  366.     // Create our application object. This MUST be the FIRST thing
  367.     // done in main(), since it initializes the Toolbox for us.
  368.     gTheApplication = new TMacTutorApp;
  369.     if (gTheApplication == nil)        // if we couldn't allocate object (impossible!?)
  370.       return 0;                        // go back to Finder
  371.     
  372.     // Start our main event loop running. This won't return until user quits
  373.     gTheApplication->EventLoop();
  374.  
  375.     // We always return a value, like good little ANSI worshippers
  376.     return 0;
  377. }
  378.  
  379.